package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern void nav_dtCompressedTile_Delete(void * c_this);
extern void nav_dtCompressedTile_DeleteArray(void * c_this);
extern void* nav_NewdtCompressedTile();
extern void * nav_dtCompressedTile_GetPtrToCompressed(void * c_this);
extern void * nav_dtCompressedTile_GetPtrToCompressedSize(void * c_this);
extern void * nav_dtCompressedTile_GetPtrToData(void * c_this);
extern void * nav_dtCompressedTile_GetPtrToDataSize(void * c_this);
extern void * nav_dtCompressedTile_GetPtrToFlags(void * c_this);
extern void * nav_dtCompressedTile_GetPtrToHeader(void * c_this);
extern void * nav_dtCompressedTile_GetPtrToNext(void * c_this);
extern void * nav_dtCompressedTile_GetPtrToSalt(void * c_this);
extern void * nav_dtCompressedTile_IndexArray(void * c_this,long n);
extern void nav_dtObstacleBox_Delete(void * c_this);
extern void nav_dtObstacleBox_DeleteArray(void * c_this);
extern void* nav_NewdtObstacleBox();
extern void * nav_dtObstacleBox_GetPtrToBmax(void * c_this);
extern void * nav_dtObstacleBox_GetPtrToBmin(void * c_this);
extern void * nav_dtObstacleBox_IndexArray(void * c_this,long n);
extern void nav_dtObstacleCylinder_Delete(void * c_this);
extern void nav_dtObstacleCylinder_DeleteArray(void * c_this);
extern void* nav_NewdtObstacleCylinder();
extern void * nav_dtObstacleCylinder_GetPtrToHeight(void * c_this);
extern void * nav_dtObstacleCylinder_GetPtrToPos(void * c_this);
extern void * nav_dtObstacleCylinder_GetPtrToRadius(void * c_this);
extern void * nav_dtObstacleCylinder_IndexArray(void * c_this,long n);
extern void nav_dtObstacleOrientedBox_Delete(void * c_this);
extern void nav_dtObstacleOrientedBox_DeleteArray(void * c_this);
extern void* nav_NewdtObstacleOrientedBox();
extern void * nav_dtObstacleOrientedBox_GetPtrToCenter(void * c_this);
extern void * nav_dtObstacleOrientedBox_GetPtrToHalfExtents(void * c_this);
extern void * nav_dtObstacleOrientedBox_GetPtrToRotAux(void * c_this);
extern void * nav_dtObstacleOrientedBox_IndexArray(void * c_this,long n);
extern unsigned int nav_dtTileCache_addBoxObstacle(void * c_this,void * bmin,void * bmax,void * result);
extern unsigned int nav_dtTileCache_addBoxObstacle11(void * c_this,void * center,void * halfExtents,float yRadians,void * result);
extern unsigned int nav_dtTileCache_addObstacle(void * c_this,void * pos,float radius,float height,void * result);
extern unsigned int nav_dtTileCache_addTile(void * c_this,void * data,int dataSize,unsigned char flags,void * result);
extern unsigned int nav_dtTileCache_buildNavMeshTile(void * c_this,unsigned int ref,void * navmesh);
extern unsigned int nav_dtTileCache_buildNavMeshTilesAt(void * c_this,int tx,int ty,void * navmesh);
extern void nav_dtTileCache_calcTightTileBounds(void * c_this,void * header,void * bmin,void * bmax);
extern unsigned int nav_dtTileCache_decodeObstacleIdObstacle(void * c_this,unsigned int ref);
extern unsigned int nav_dtTileCache_decodeObstacleIdSalt(void * c_this,unsigned int ref);
extern unsigned int nav_dtTileCache_decodeTileIdSalt(void * c_this,unsigned int ref);
extern unsigned int nav_dtTileCache_decodeTileIdTile(void * c_this,unsigned int ref);
extern void nav_dtTileCache_Delete(void * c_this);
extern void nav_dtTileCache_DeleteArray(void * c_this);
extern void* nav_NewdtTileCache();
extern unsigned int nav_dtTileCache_encodeObstacleId(void * c_this,unsigned int salt,unsigned int it);
extern unsigned int nav_dtTileCache_encodeTileId(void * c_this,unsigned int salt,unsigned int it);
extern void * nav_dtTileCache_getAlloc(void * c_this);
extern void * nav_dtTileCache_getCompressor(void * c_this);
extern void * nav_dtTileCache_getObstacle(void * c_this,int i);
extern void nav_dtTileCache_getObstacleBounds(void * c_this,void * ob,void * bmin,void * bmax);
extern void * nav_dtTileCache_getObstacleByRef(void * c_this,unsigned int ref);
extern int nav_dtTileCache_getObstacleCount(void * c_this);
extern unsigned int nav_dtTileCache_getObstacleRef(void * c_this,void * obmin);
extern void * nav_dtTileCache_getParams(void * c_this);
extern void * nav_dtTileCache_getTile(void * c_this,int i);
extern void * nav_dtTileCache_getTileAt(void * c_this,int tx,int ty,int tlayer);
extern void * nav_dtTileCache_getTileByRef(void * c_this,unsigned int ref);
extern int nav_dtTileCache_getTileCount(void * c_this);
extern unsigned int nav_dtTileCache_getTileRef(void * c_this,void * tile);
extern int nav_dtTileCache_getTilesAt(void * c_this,int tx,int ty,void * tiles,int maxTiles);
extern void * nav_dtTileCache_IndexArray(void * c_this,long n);
extern unsigned int nav_dtTileCache_init(void * c_this,void * params,void * talloc,void * tcomp,void * tmproc);
extern unsigned int nav_dtTileCache_queryTiles(void * c_this,void * bmin,void * bmax,void * results,void * resultCount,int maxResults);
extern unsigned int nav_dtTileCache_removeObstacle(void * c_this,unsigned int ref);
extern unsigned int nav_dtTileCache_removeTile(void * c_this,unsigned int ref,void * data,void * dataSize);
extern unsigned int nav_dtTileCache_update(void * c_this,float dt,void * navmesh,void * upToDate);
extern void nav_dtTileCacheMeshProcess_Delete(void * c_this);
extern void nav_dtTileCacheMeshProcess_process(void * c_this,void * params,void * polyAreas,void * polyFlags);
extern void nav_dtTileCacheObstacle_Delete(void * c_this);
extern void nav_dtTileCacheObstacle_DeleteArray(void * c_this);
extern void* nav_NewdtTileCacheObstacle();
extern void * nav_dtTileCacheObstacle_GetPtrToNext(void * c_this);
extern void * nav_dtTileCacheObstacle_GetPtrToNpending(void * c_this);
extern void * nav_dtTileCacheObstacle_GetPtrToNtouched(void * c_this);
extern void * nav_dtTileCacheObstacle_GetPtrToPending(void * c_this);
extern void * nav_dtTileCacheObstacle_GetPtrToSalt(void * c_this);
extern void * nav_dtTileCacheObstacle_GetPtrToState(void * c_this);
extern void * nav_dtTileCacheObstacle_GetPtrToTouched(void * c_this);
extern void * nav_dtTileCacheObstacle_GetPtrToType(void * c_this);
extern void * nav_dtTileCacheObstacle_IndexArray(void * c_this,long n);
extern void nav_dtTileCacheParams_Delete(void * c_this);
extern void nav_dtTileCacheParams_DeleteArray(void * c_this);
extern void* nav_NewdtTileCacheParams();
extern void * nav_dtTileCacheParams_GetPtrToCh(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToCs(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToHeight(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToMaxObstacles(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToMaxSimplificationError(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToMaxTiles(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToOrig(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToWalkableClimb(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToWalkableHeight(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToWalkableRadius(void * c_this);
extern void * nav_dtTileCacheParams_GetPtrToWidth(void * c_this);
extern void * nav_dtTileCacheParams_IndexArray(void * c_this,long n);
extern void * nav_dtAllocTileCache();
extern void nav_dtFreeTileCache(void * tc);
extern void * nav_NewDtCompressedTilePtrArray(long n);
extern void * nav_NewDtObstacleBoxPtrArray(long n);
extern void * nav_NewDtObstacleCylinderPtrArray(long n);
extern void * nav_NewDtObstacleOrientedBoxPtrArray(long n);
extern void * nav_NewDtTileCacheObstaclePtrArray(long n);
extern void * nav_NewDtTileCacheParamsPtrArray(long n);
extern void * nav_NewDtTileCachePtrArray(long n);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

type DtCompressedTilePtr uintptr

/*
public void Delete()
*/
func (p DtCompressedTilePtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCompressedTile_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtCompressedTilePtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCompressedTile_DeleteArray(wrap_this)
}

/*
public dtCompressedTile()
*/
func NewDtCompressedTile() cgo.GoManagedPtr[DtCompressedTilePtr] {
	wrap_out := C.nav_NewdtCompressedTile()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtCompressedTilePtr]](uintptr(wrap_out))
	return go_out
}

/*
public unsigned char * * GetPtrToCompressed()
*/
func (p DtCompressedTilePtr) GetPtrToCompressed() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToCompressed(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToCompressedSize()
*/
func (p DtCompressedTilePtr) GetPtrToCompressedSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToCompressedSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * * GetPtrToData()
*/
func (p DtCompressedTilePtr) GetPtrToData() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToData(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToDataSize()
*/
func (p DtCompressedTilePtr) GetPtrToDataSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToDataSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned int * GetPtrToFlags()
*/
func (p DtCompressedTilePtr) GetPtrToFlags() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToFlags(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public dtTileCacheLayerHeader * * GetPtrToHeader()
*/
func (p DtCompressedTilePtr) GetPtrToHeader() *DtTileCacheLayerHeaderPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToHeader(wrap_this)
	go_out := (*DtTileCacheLayerHeaderPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public dtCompressedTile * * GetPtrToNext()
*/
func (p DtCompressedTilePtr) GetPtrToNext() *DtCompressedTilePtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToNext(wrap_this)
	go_out := (*DtCompressedTilePtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Counter describing modifications to the tile.

public unsigned int * GetPtrToSalt()
*/
func (p DtCompressedTilePtr) GetPtrToSalt() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_GetPtrToSalt(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtCompressedTile * IndexArray(long n)
*/
func (p DtCompressedTilePtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCompressedTile_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtObstacleBoxPtr uintptr

/*
public void Delete()
*/
func (p DtObstacleBoxPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtObstacleBox_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtObstacleBoxPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtObstacleBox_DeleteArray(wrap_this)
}

/*
public dtObstacleBox()
*/
func NewDtObstacleBox() cgo.GoManagedPtr[DtObstacleBoxPtr] {
	wrap_out := C.nav_NewdtObstacleBox()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtObstacleBoxPtr]](uintptr(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToBmax()
*/
func (p DtObstacleBoxPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleBox_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToBmin()
*/
func (p DtObstacleBoxPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleBox_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtObstacleBox * IndexArray(long n)
*/
func (p DtObstacleBoxPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleBox_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtObstacleCylinderPtr uintptr

/*
public void Delete()
*/
func (p DtObstacleCylinderPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtObstacleCylinder_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtObstacleCylinderPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtObstacleCylinder_DeleteArray(wrap_this)
}

/*
public dtObstacleCylinder()
*/
func NewDtObstacleCylinder() cgo.GoManagedPtr[DtObstacleCylinderPtr] {
	wrap_out := C.nav_NewdtObstacleCylinder()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtObstacleCylinderPtr]](uintptr(wrap_out))
	return go_out
}

/*
public float * GetPtrToHeight()
*/
func (p DtObstacleCylinderPtr) GetPtrToHeight() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleCylinder_GetPtrToHeight(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToPos()
*/
func (p DtObstacleCylinderPtr) GetPtrToPos() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleCylinder_GetPtrToPos(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToRadius()
*/
func (p DtObstacleCylinderPtr) GetPtrToRadius() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleCylinder_GetPtrToRadius(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtObstacleCylinder * IndexArray(long n)
*/
func (p DtObstacleCylinderPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleCylinder_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtObstacleOrientedBoxPtr uintptr

/*
public void Delete()
*/
func (p DtObstacleOrientedBoxPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtObstacleOrientedBox_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtObstacleOrientedBoxPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtObstacleOrientedBox_DeleteArray(wrap_this)
}

/*
public dtObstacleOrientedBox()
*/
func NewDtObstacleOrientedBox() cgo.GoManagedPtr[DtObstacleOrientedBoxPtr] {
	wrap_out := C.nav_NewdtObstacleOrientedBox()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtObstacleOrientedBoxPtr]](uintptr(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToCenter()
*/
func (p DtObstacleOrientedBoxPtr) GetPtrToCenter() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleOrientedBox_GetPtrToCenter(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToHalfExtents()
*/
func (p DtObstacleOrientedBoxPtr) GetPtrToHalfExtents() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleOrientedBox_GetPtrToHalfExtents(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
{ cos(0.5f*angle)*sin(-0.5f*angle); cos(0.5f*angle)*cos(0.5f*angle) - 0.5 }

public float(*)[2] GetPtrToRotAux()
*/
func (p DtObstacleOrientedBoxPtr) GetPtrToRotAux() *[2]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleOrientedBox_GetPtrToRotAux(wrap_this)
	go_out := (*[2]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtObstacleOrientedBox * IndexArray(long n)
*/
func (p DtObstacleOrientedBoxPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtObstacleOrientedBox_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtTileCachePtr uintptr

/*
Aabb obstacle.

public dtStatus addBoxObstacle(float const * bmin, float const * bmax, dtObstacleRef * result)
*/
func (p DtTileCachePtr) AddBoxObstacle(bmin *float32, bmax *float32, result *uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_bmin unsafe.Pointer
	var wrap_arg_bmax unsafe.Pointer
	var wrap_arg_result unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_bmin = (unsafe.Pointer)(bmin)
	wrap_arg_bmax = (unsafe.Pointer)(bmax)
	wrap_arg_result = (unsafe.Pointer)(result)
	wrap_out := C.nav_dtTileCache_addBoxObstacle(wrap_this, wrap_arg_bmin, wrap_arg_bmax, wrap_arg_result)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Box obstacle: can be rotated in Y.

public dtStatus addBoxObstacle(float const * center, float const * halfExtents, float const yRadians, dtObstacleRef * result)
*/
func (p DtTileCachePtr) AddBoxObstacle11(center *float32, halfExtents *float32, yRadians float32, result *uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_center unsafe.Pointer
	var wrap_arg_halfExtents unsafe.Pointer
	var wrap_arg_yRadians C.float
	var wrap_arg_result unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_center = (unsafe.Pointer)(center)
	wrap_arg_halfExtents = (unsafe.Pointer)(halfExtents)
	wrap_arg_yRadians = (C.float)(yRadians)
	wrap_arg_result = (unsafe.Pointer)(result)
	wrap_out := C.nav_dtTileCache_addBoxObstacle11(wrap_this, wrap_arg_center, wrap_arg_halfExtents, wrap_arg_yRadians, wrap_arg_result)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Cylinder obstacle.

public dtStatus addObstacle(float const * pos, float const radius, float const height, dtObstacleRef * result)
*/
func (p DtTileCachePtr) AddObstacle(pos *float32, radius float32, height float32, result *uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_radius C.float
	var wrap_arg_height C.float
	var wrap_arg_result unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_radius = (C.float)(radius)
	wrap_arg_height = (C.float)(height)
	wrap_arg_result = (unsafe.Pointer)(result)
	wrap_out := C.nav_dtTileCache_addObstacle(wrap_this, wrap_arg_pos, wrap_arg_radius, wrap_arg_height, wrap_arg_result)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtStatus addTile(unsigned char * data, int const dataSize, unsigned char flags, dtCompressedTileRef * result)
*/
func (p DtTileCachePtr) AddTile(data *uint8, dataSize int32, flags uint8, result *uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_dataSize C.int
	var wrap_arg_flags C.uchar
	var wrap_arg_result unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_dataSize = (C.int)(dataSize)
	wrap_arg_flags = (C.uchar)(flags)
	wrap_arg_result = (unsafe.Pointer)(result)
	wrap_out := C.nav_dtTileCache_addTile(wrap_this, wrap_arg_data, wrap_arg_dataSize, wrap_arg_flags, wrap_arg_result)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtStatus buildNavMeshTile(dtCompressedTileRef const ref, dtNavMesh * navmesh)
*/
func (p DtTileCachePtr) BuildNavMeshTile(ref uint32, navmesh DtNavMeshPtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_navmesh unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_navmesh = (unsafe.Pointer)(navmesh)
	wrap_out := C.nav_dtTileCache_buildNavMeshTile(wrap_this, wrap_arg_ref, wrap_arg_navmesh)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtStatus buildNavMeshTilesAt(int const tx, int const ty, dtNavMesh * navmesh)
*/
func (p DtTileCachePtr) BuildNavMeshTilesAt(tx int32, ty int32, navmesh DtNavMeshPtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tx C.int
	var wrap_arg_ty C.int
	var wrap_arg_navmesh unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tx = (C.int)(tx)
	wrap_arg_ty = (C.int)(ty)
	wrap_arg_navmesh = (unsafe.Pointer)(navmesh)
	wrap_out := C.nav_dtTileCache_buildNavMeshTilesAt(wrap_this, wrap_arg_tx, wrap_arg_ty, wrap_arg_navmesh)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public void calcTightTileBounds(dtTileCacheLayerHeader const * header, float * bmin, float * bmax) const
*/
func (p DtTileCachePtr) CalcTightTileBounds(header DtTileCacheLayerHeaderPtr, bmin *float32, bmax *float32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_header unsafe.Pointer
	var wrap_arg_bmin unsafe.Pointer
	var wrap_arg_bmax unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_header = (unsafe.Pointer)(header)
	wrap_arg_bmin = (unsafe.Pointer)(bmin)
	wrap_arg_bmax = (unsafe.Pointer)(bmax)
	C.nav_dtTileCache_calcTightTileBounds(wrap_this, wrap_arg_header, wrap_arg_bmin, wrap_arg_bmax)
}

/*
Decodes an obstacle id.

public unsigned int decodeObstacleIdObstacle(dtObstacleRef ref) const
*/
func (p DtTileCachePtr) DecodeObstacleIdObstacle(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtTileCache_decodeObstacleIdObstacle(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Decodes an obstacle salt.

public unsigned int decodeObstacleIdSalt(dtObstacleRef ref) const
*/
func (p DtTileCachePtr) DecodeObstacleIdSalt(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtTileCache_decodeObstacleIdSalt(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Decodes a tile salt.

public unsigned int decodeTileIdSalt(dtCompressedTileRef ref) const
*/
func (p DtTileCachePtr) DecodeTileIdSalt(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtTileCache_decodeTileIdSalt(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Decodes a tile id.

public unsigned int decodeTileIdTile(dtCompressedTileRef ref) const
*/
func (p DtTileCachePtr) DecodeTileIdTile(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtTileCache_decodeTileIdTile(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public void Delete()
*/
func (p DtTileCachePtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCache_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCachePtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCache_DeleteArray(wrap_this)
}

/*
public dtTileCache()
*/
func NewDtTileCache() cgo.GoManagedPtr[DtTileCachePtr] {
	wrap_out := C.nav_NewdtTileCache()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCachePtr]](uintptr(wrap_out))
	return go_out
}

/*
Encodes an obstacle id.

public dtObstacleRef encodeObstacleId(unsigned int salt, unsigned int it) const
*/
func (p DtTileCachePtr) EncodeObstacleId(salt uint32, it uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_salt C.uint
	var wrap_arg_it C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_salt = (C.uint)(salt)
	wrap_arg_it = (C.uint)(it)
	wrap_out := C.nav_dtTileCache_encodeObstacleId(wrap_this, wrap_arg_salt, wrap_arg_it)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Encodes a tile id.

public dtCompressedTileRef encodeTileId(unsigned int salt, unsigned int it) const
*/
func (p DtTileCachePtr) EncodeTileId(salt uint32, it uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_salt C.uint
	var wrap_arg_it C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_salt = (C.uint)(salt)
	wrap_arg_it = (C.uint)(it)
	wrap_out := C.nav_dtTileCache_encodeTileId(wrap_this, wrap_arg_salt, wrap_arg_it)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtTileCacheAlloc * getAlloc()
*/
func (p DtTileCachePtr) GetAlloc() DtTileCacheAllocPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCache_getAlloc(wrap_this)
	go_out := cgo.MakePtr[DtTileCacheAllocPtr](uintptr(wrap_out))
	return go_out
}

/*
public dtTileCacheCompressor * getCompressor()
*/
func (p DtTileCachePtr) GetCompressor() DtTileCacheCompressorPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCache_getCompressor(wrap_this)
	go_out := cgo.MakePtr[DtTileCacheCompressorPtr](uintptr(wrap_out))
	return go_out
}

/*
public dtTileCacheObstacle const * getObstacle(int const i) const
*/
func (p DtTileCachePtr) GetObstacle(i int32) DtTileCacheObstaclePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_i C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_i = (C.int)(i)
	wrap_out := C.nav_dtTileCache_getObstacle(wrap_this, wrap_arg_i)
	go_out := cgo.MakePtr[DtTileCacheObstaclePtr](uintptr(wrap_out))
	return go_out
}

/*
public void getObstacleBounds(dtTileCacheObstacle const * ob, float * bmin, float * bmax) const
*/
func (p DtTileCachePtr) GetObstacleBounds(ob DtTileCacheObstaclePtr, bmin *float32, bmax *float32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_ob unsafe.Pointer
	var wrap_arg_bmin unsafe.Pointer
	var wrap_arg_bmax unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ob = (unsafe.Pointer)(ob)
	wrap_arg_bmin = (unsafe.Pointer)(bmin)
	wrap_arg_bmax = (unsafe.Pointer)(bmax)
	C.nav_dtTileCache_getObstacleBounds(wrap_this, wrap_arg_ob, wrap_arg_bmin, wrap_arg_bmax)
}

/*
public dtTileCacheObstacle const * getObstacleByRef(dtObstacleRef ref)
*/
func (p DtTileCachePtr) GetObstacleByRef(ref uint32) DtTileCacheObstaclePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtTileCache_getObstacleByRef(wrap_this, wrap_arg_ref)
	go_out := cgo.MakePtr[DtTileCacheObstaclePtr](uintptr(wrap_out))
	return go_out
}

/*
public int getObstacleCount() const
*/
func (p DtTileCachePtr) GetObstacleCount() int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCache_getObstacleCount(wrap_this)
	go_out := int32(wrap_out)
	return go_out
}

/*
public dtObstacleRef getObstacleRef(dtTileCacheObstacle const * obmin) const
*/
func (p DtTileCachePtr) GetObstacleRef(obmin DtTileCacheObstaclePtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_obmin unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_obmin = (unsafe.Pointer)(obmin)
	wrap_out := C.nav_dtTileCache_getObstacleRef(wrap_this, wrap_arg_obmin)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtTileCacheParams const * getParams() const
*/
func (p DtTileCachePtr) GetParams() DtTileCacheParamsPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCache_getParams(wrap_this)
	go_out := cgo.MakePtr[DtTileCacheParamsPtr](uintptr(wrap_out))
	return go_out
}

/*
public dtCompressedTile const * getTile(int const i) const
*/
func (p DtTileCachePtr) GetTile(i int32) DtCompressedTilePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_i C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_i = (C.int)(i)
	wrap_out := C.nav_dtTileCache_getTile(wrap_this, wrap_arg_i)
	go_out := cgo.MakePtr[DtCompressedTilePtr](uintptr(wrap_out))
	return go_out
}

/*
public dtCompressedTile * getTileAt(int const tx, int const ty, int const tlayer)
*/
func (p DtTileCachePtr) GetTileAt(tx int32, ty int32, tlayer int32) DtCompressedTilePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_tx C.int
	var wrap_arg_ty C.int
	var wrap_arg_tlayer C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tx = (C.int)(tx)
	wrap_arg_ty = (C.int)(ty)
	wrap_arg_tlayer = (C.int)(tlayer)
	wrap_out := C.nav_dtTileCache_getTileAt(wrap_this, wrap_arg_tx, wrap_arg_ty, wrap_arg_tlayer)
	go_out := cgo.MakePtr[DtCompressedTilePtr](uintptr(wrap_out))
	return go_out
}

/*
public dtCompressedTile const * getTileByRef(dtCompressedTileRef ref) const
*/
func (p DtTileCachePtr) GetTileByRef(ref uint32) DtCompressedTilePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtTileCache_getTileByRef(wrap_this, wrap_arg_ref)
	go_out := cgo.MakePtr[DtCompressedTilePtr](uintptr(wrap_out))
	return go_out
}

/*
public int getTileCount() const
*/
func (p DtTileCachePtr) GetTileCount() int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCache_getTileCount(wrap_this)
	go_out := int32(wrap_out)
	return go_out
}

/*
public dtCompressedTileRef getTileRef(dtCompressedTile const * tile) const
*/
func (p DtTileCachePtr) GetTileRef(tile DtCompressedTilePtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tile unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_out := C.nav_dtTileCache_getTileRef(wrap_this, wrap_arg_tile)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public int getTilesAt(int const tx, int const ty, dtCompressedTileRef * tiles, int const maxTiles) const
*/
func (p DtTileCachePtr) GetTilesAt(tx int32, ty int32, tiles *uint32, maxTiles int32) int32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tx C.int
	var wrap_arg_ty C.int
	var wrap_arg_tiles unsafe.Pointer
	var wrap_arg_maxTiles C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tx = (C.int)(tx)
	wrap_arg_ty = (C.int)(ty)
	wrap_arg_tiles = (unsafe.Pointer)(tiles)
	wrap_arg_maxTiles = (C.int)(maxTiles)
	wrap_out := C.nav_dtTileCache_getTilesAt(wrap_this, wrap_arg_tx, wrap_arg_ty, wrap_arg_tiles, wrap_arg_maxTiles)
	go_out := int32(wrap_out)
	return go_out
}

/*
dtTileCache * IndexArray(long n)
*/
func (p DtTileCachePtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCache_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public dtStatus init(dtTileCacheParams const * params, dtTileCacheAlloc * talloc, dtTileCacheCompressor * tcomp, dtTileCacheMeshProcess * tmproc)
*/
func (p DtTileCachePtr) Init(params DtTileCacheParamsPtr, talloc DtTileCacheAllocPtr, tcomp DtTileCacheCompressorPtr, tmproc DtTileCacheMeshProcessPtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_params unsafe.Pointer
	var wrap_arg_talloc unsafe.Pointer
	var wrap_arg_tcomp unsafe.Pointer
	var wrap_arg_tmproc unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_params = (unsafe.Pointer)(params)
	wrap_arg_talloc = (unsafe.Pointer)(talloc)
	wrap_arg_tcomp = (unsafe.Pointer)(tcomp)
	wrap_arg_tmproc = (unsafe.Pointer)(tmproc)
	wrap_out := C.nav_dtTileCache_init(wrap_this, wrap_arg_params, wrap_arg_talloc, wrap_arg_tcomp, wrap_arg_tmproc)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtStatus queryTiles(float const * bmin, float const * bmax, dtCompressedTileRef * results, int * resultCount, int const maxResults) const
*/
func (p DtTileCachePtr) QueryTiles(bmin *float32, bmax *float32, results *uint32, resultCount *int32, maxResults int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_bmin unsafe.Pointer
	var wrap_arg_bmax unsafe.Pointer
	var wrap_arg_results unsafe.Pointer
	var wrap_arg_resultCount unsafe.Pointer
	var wrap_arg_maxResults C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_bmin = (unsafe.Pointer)(bmin)
	wrap_arg_bmax = (unsafe.Pointer)(bmax)
	wrap_arg_results = (unsafe.Pointer)(results)
	wrap_arg_resultCount = (unsafe.Pointer)(resultCount)
	wrap_arg_maxResults = (C.int)(maxResults)
	wrap_out := C.nav_dtTileCache_queryTiles(wrap_this, wrap_arg_bmin, wrap_arg_bmax, wrap_arg_results, wrap_arg_resultCount, wrap_arg_maxResults)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtStatus removeObstacle(dtObstacleRef const ref)
*/
func (p DtTileCachePtr) RemoveObstacle(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtTileCache_removeObstacle(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public dtStatus removeTile(dtCompressedTileRef ref, unsigned char * * data, int * dataSize)
*/
func (p DtTileCachePtr) RemoveTile(ref uint32, data **uint8, dataSize *int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_dataSize unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_dataSize = (unsafe.Pointer)(dataSize)
	wrap_out := C.nav_dtTileCache_removeTile(wrap_this, wrap_arg_ref, wrap_arg_data, wrap_arg_dataSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Updates the tile cache by rebuilding tiles touched by unfinished obstacle requests.

@param dt The time step size. Currently not used.
@param navmesh The mesh to affect when rebuilding tiles.
@param upToDate Whether the tile cache is fully up to date with obstacle requests and tile rebuilds.
If the tile cache is up to date another (immediate) call to update will have no effect;
otherwise another call will continue processing obstacle requests and tile rebuilds.

public dtStatus update(float const dt, dtNavMesh * navmesh, bool * upToDate=0)
*/
func (p DtTileCachePtr) Update(dt float32, navmesh DtNavMeshPtr, upToDate *bool) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_dt C.float
	var wrap_arg_navmesh unsafe.Pointer
	var wrap_arg_upToDate unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_dt = (C.float)(dt)
	wrap_arg_navmesh = (unsafe.Pointer)(navmesh)
	wrap_arg_upToDate = (unsafe.Pointer)(upToDate)
	wrap_out := C.nav_dtTileCache_update(wrap_this, wrap_arg_dt, wrap_arg_navmesh, wrap_arg_upToDate)
	go_out := uint32(wrap_out)
	return go_out
}

type DtTileCacheMeshProcessPtr uintptr

/*
public virtual void Delete()
*/
func (p DtTileCacheMeshProcessPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheMeshProcess_Delete(wrap_this)
}

/*
public virtual void process(dtNavMeshCreateParams * params, unsigned char * polyAreas, unsigned short * polyFlags) = 0
*/
func (p DtTileCacheMeshProcessPtr) Process(params DtNavMeshCreateParamsPtr, polyAreas *uint8, polyFlags *uint16) {
	var wrap_this unsafe.Pointer
	var wrap_arg_params unsafe.Pointer
	var wrap_arg_polyAreas unsafe.Pointer
	var wrap_arg_polyFlags unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_params = (unsafe.Pointer)(params)
	wrap_arg_polyAreas = (unsafe.Pointer)(polyAreas)
	wrap_arg_polyFlags = (unsafe.Pointer)(polyFlags)
	C.nav_dtTileCacheMeshProcess_process(wrap_this, wrap_arg_params, wrap_arg_polyAreas, wrap_arg_polyFlags)
}

type DtTileCacheObstaclePtr uintptr

/*
public void Delete()
*/
func (p DtTileCacheObstaclePtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheObstacle_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCacheObstaclePtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheObstacle_DeleteArray(wrap_this)
}

/*
public dtTileCacheObstacle()
*/
func NewDtTileCacheObstacle() cgo.GoManagedPtr[DtTileCacheObstaclePtr] {
	wrap_out := C.nav_NewdtTileCacheObstacle()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCacheObstaclePtr]](uintptr(wrap_out))
	return go_out
}

/*
public dtTileCacheObstacle * * GetPtrToNext()
*/
func (p DtTileCacheObstaclePtr) GetPtrToNext() *DtTileCacheObstaclePtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToNext(wrap_this)
	go_out := (*DtTileCacheObstaclePtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * GetPtrToNpending()
*/
func (p DtTileCacheObstaclePtr) GetPtrToNpending() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToNpending(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * GetPtrToNtouched()
*/
func (p DtTileCacheObstaclePtr) GetPtrToNtouched() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToNtouched(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public dtCompressedTileRef(*)[8] GetPtrToPending()
*/
func (p DtTileCacheObstaclePtr) GetPtrToPending() *[8]uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToPending(wrap_this)
	go_out := (*[8]uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned short * GetPtrToSalt()
*/
func (p DtTileCacheObstaclePtr) GetPtrToSalt() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToSalt(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * GetPtrToState()
*/
func (p DtTileCacheObstaclePtr) GetPtrToState() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToState(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public dtCompressedTileRef(*)[8] GetPtrToTouched()
*/
func (p DtTileCacheObstaclePtr) GetPtrToTouched() *[8]uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToTouched(wrap_this)
	go_out := (*[8]uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * GetPtrToType()
*/
func (p DtTileCacheObstaclePtr) GetPtrToType() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_GetPtrToType(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtTileCacheObstacle * IndexArray(long n)
*/
func (p DtTileCacheObstaclePtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheObstacle_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtTileCacheParamsPtr uintptr

/*
public void Delete()
*/
func (p DtTileCacheParamsPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheParams_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCacheParamsPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheParams_DeleteArray(wrap_this)
}

/*
public dtTileCacheParams()
*/
func NewDtTileCacheParams() cgo.GoManagedPtr[DtTileCacheParamsPtr] {
	wrap_out := C.nav_NewdtTileCacheParams()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCacheParamsPtr]](uintptr(wrap_out))
	return go_out
}

/*
public float * GetPtrToCh()
*/
func (p DtTileCacheParamsPtr) GetPtrToCh() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToCh(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToCs()
*/
func (p DtTileCacheParamsPtr) GetPtrToCs() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToCs(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToHeight()
*/
func (p DtTileCacheParamsPtr) GetPtrToHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToMaxObstacles()
*/
func (p DtTileCacheParamsPtr) GetPtrToMaxObstacles() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToMaxObstacles(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToMaxSimplificationError()
*/
func (p DtTileCacheParamsPtr) GetPtrToMaxSimplificationError() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToMaxSimplificationError(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToMaxTiles()
*/
func (p DtTileCacheParamsPtr) GetPtrToMaxTiles() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToMaxTiles(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToOrig()
*/
func (p DtTileCacheParamsPtr) GetPtrToOrig() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToOrig(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToWalkableClimb()
*/
func (p DtTileCacheParamsPtr) GetPtrToWalkableClimb() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToWalkableClimb(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToWalkableHeight()
*/
func (p DtTileCacheParamsPtr) GetPtrToWalkableHeight() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToWalkableHeight(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToWalkableRadius()
*/
func (p DtTileCacheParamsPtr) GetPtrToWalkableRadius() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToWalkableRadius(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToWidth()
*/
func (p DtTileCacheParamsPtr) GetPtrToWidth() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_GetPtrToWidth(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtTileCacheParams * IndexArray(long n)
*/
func (p DtTileCacheParamsPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheParams_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
dtTileCache * dtAllocTileCache()
*/
func DtAllocTileCache() DtTileCachePtr {
	wrap_out := C.nav_dtAllocTileCache()
	go_out := cgo.MakePtr[DtTileCachePtr](uintptr(wrap_out))
	return go_out
}

/*
void dtFreeTileCache(dtTileCache * tc)
*/
func DtFreeTileCache(tc DtTileCachePtr) {
	var wrap_arg_tc unsafe.Pointer
	wrap_arg_tc = (unsafe.Pointer)(tc)
	C.nav_dtFreeTileCache(wrap_arg_tc)
}

/*
dtCompressedTile * NewDtCompressedTilePtrArray(long n)
*/
func NewDtCompressedTilePtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtCompressedTilePtr]] {
	wrap_out := C.nav_NewDtCompressedTilePtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtCompressedTilePtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtObstacleBox * NewDtObstacleBoxPtrArray(long n)
*/
func NewDtObstacleBoxPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtObstacleBoxPtr]] {
	wrap_out := C.nav_NewDtObstacleBoxPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtObstacleBoxPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtObstacleCylinder * NewDtObstacleCylinderPtrArray(long n)
*/
func NewDtObstacleCylinderPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtObstacleCylinderPtr]] {
	wrap_out := C.nav_NewDtObstacleCylinderPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtObstacleCylinderPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtObstacleOrientedBox * NewDtObstacleOrientedBoxPtrArray(long n)
*/
func NewDtObstacleOrientedBoxPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtObstacleOrientedBoxPtr]] {
	wrap_out := C.nav_NewDtObstacleOrientedBoxPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtObstacleOrientedBoxPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCacheObstacle * NewDtTileCacheObstaclePtrArray(long n)
*/
func NewDtTileCacheObstaclePtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCacheObstaclePtr]] {
	wrap_out := C.nav_NewDtTileCacheObstaclePtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCacheObstaclePtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCacheParams * NewDtTileCacheParamsPtrArray(long n)
*/
func NewDtTileCacheParamsPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCacheParamsPtr]] {
	wrap_out := C.nav_NewDtTileCacheParamsPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCacheParamsPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCache * NewDtTileCachePtrArray(long n)
*/
func NewDtTileCachePtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCachePtr]] {
	wrap_out := C.nav_NewDtTileCachePtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCachePtr]]](uintptr(wrap_out))
	return go_out
}

/*
Flags for addTile
*/
type EnumDtCompressedTileFlags uint32

const (
	/*
	   Navmesh owns the tile memory and should free it.
	*/
	EnumDtCompressedTileFlags_DT_COMPRESSEDTILE_FREE_DATA EnumDtCompressedTileFlags = 1
)

type EnumDtTileCacheObstacleRequestAction uint32

const (
	EnumDtTileCacheObstacleRequestAction_REQUEST_ADD    EnumDtTileCacheObstacleRequestAction = 0
	EnumDtTileCacheObstacleRequestAction_REQUEST_REMOVE EnumDtTileCacheObstacleRequestAction = 1
)

type EnumObstacleState uint32

const (
	EnumObstacleState_DT_OBSTACLE_EMPTY      EnumObstacleState = 0
	EnumObstacleState_DT_OBSTACLE_PROCESSING EnumObstacleState = 1
	EnumObstacleState_DT_OBSTACLE_PROCESSED  EnumObstacleState = 2
	EnumObstacleState_DT_OBSTACLE_REMOVING   EnumObstacleState = 3
)

type EnumObstacleType uint32

const (
	EnumObstacleType_DT_OBSTACLE_CYLINDER EnumObstacleType = 0
	/*
	   AABB
	*/
	EnumObstacleType_DT_OBSTACLE_BOX EnumObstacleType = 1
	/*
	   OBB
	*/
	EnumObstacleType_DT_OBSTACLE_ORIENTED_BOX EnumObstacleType = 2
)
